//
//  YBString.swift
//  LeetCodeDemo
//
//  Created by Clover on 2018/7/3.
//  Copyright © 2018年 longbei.com. All rights reserved.
//

import UIKit

class YBString: NSObject {
    /*
     请编写一个函数，其功能是将输入的字符串反转过来。
     
     示例：
     
     输入：s = "hello"
     返回："olleh"
     */
    func reverseString(_ s: String) -> String {
        return  String(s.reversed())
    }
    /*
     给定一个 32 位有符号整数，将整数中的数字进行反转。
     
     示例 1:
     
     输入: 123
     输出: 321
     示例 2:
     
     输入: -123
     输出: -321
     示例 3:
     
     输入: 120
     输出: 21
     注意:
     
     假设我们的环境只能存储 32 位有符号整数，其数值范围是 [−231,  231 − 1]。根据这个假设，如果反转后的整数溢出，则返回 0。
     */
    func reverse(_ x: Int) -> Int {
        var str = ""
        var isZero = false
        if x >= 0 {
            str = "\(x)"
        }else{
            isZero = true
            str = "\(x * -1)"
        }
        let newStr = String(str.reversed())
        
        var newValue = Int.init(newStr) ?? 0
        if isZero{
            newValue *= -1
        }
        if newValue < -2147483648 || newValue > 2147483647 {
            newValue = 0
        }
        return Int(newValue)
    }
    
    /*
     
     给定一个字符串，找到它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1。
     
     案例:
     
     s = "leetcode"
     返回 0.
     
     s = "loveleetcode",
     返回 2.
     
     
     注意事项：您可以假定该字符串只包含小写字母。
     */
    func firstUniqChar(_ s: String) -> Int {
        if s.count == 0 {
            return -1
        }
        var lastIndex = -1
        var isEqule = false
        for (index,value) in s.enumerated(){
            for nextIndex in 0..<s.count{
                if index == nextIndex {
                    continue
                }
                let tempChar = s[s.index(String.Index.init(encodedOffset: nextIndex), offsetBy: 0)]
                if value == tempChar {
                    isEqule = true
                    break
                }else{
                    isEqule = false
                }
            }
            if isEqule == false {
                lastIndex = index
                break
            }
        }
        return lastIndex
    }
    
    /*
     给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的一个字母异位词。
     
     示例 1:
     
     输入: s = "anagram", t = "nagaram"
     输出: true
     示例 2:
     
     输入: s = "rat", t = "car"
     输出: false
     说明:
     你可以假设字符串只包含小写字母。
     
     进阶:
     如果输入字符串包含 unicode 字符怎么办？你能否调整你的解法来应对这种情况？
     */
    func isAnagram(_ s: String, _ t: String) -> Bool {
        if s.count != t.count{
            return false
        }
        var sList: [Character] = []
        var tList: [Character] = []
        for s_char in s{
            sList.append(s_char)
        }
        for t_char in t{
            tList.append(t_char)
        }
        
        for char in sList{
            if let tindex = tList.index(of: char){
                tList.remove(at: tindex)
            }
        }
        return tList.count == 0
    }
    
    /*
     给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。
     
     说明：本题中，我们将空字符串定义为有效的回文串。
     
     示例 1:
     
     输入: "A man, a plan, a canal: Panama"
     输出: true
     示例 2:
     
     输入: "race a car"
     输出: false
     */
    func isPalindrome(_ s: String) -> Bool {
        if s.count == 0 {return false}
        s.lowercased()
        var strArr: [Character] = []
        for char in s {
            if char > "z" && char < "a"{
                strArr.append(char)
            }
        }
        
        var mid = 0
        if strArr.count % 2 == 0 {// 偶数
            mid = strArr.count / 2 - 1
        }else{ // 奇数
            mid = strArr.count / 2
        }
        
//        for <#item#> in <#items#> {
//            <#code#>
//        }
        return true
    }
    
    func replaceSpace(_ s: String) -> String {
        var newStr = s.replacingOccurrences(of: " ", with: "%")
        return newStr
    }
}


